﻿//using System;
//using System.Collections;
//using System.Collections.Generic;
//using System.IO;
//using System.Security.Cryptography;
//using System.Text;

//namespace ARS.Common.Helper
//{
//    public class EncryptHelper
//    {
//        private static string sKey = "KedeBigData";
//        /// <summary>
//        /// DES 加密
//        /// </summary>
//        /// <param name="input"></param>
//        /// <param name="key"></param>
//        /// <returns></returns>
//        public static string DesEncrypt(string input, string key)
//        {

//            byte[] inputArray = Encoding.UTF8.GetBytes(input);
//            var tripleDES = TripleDES.Create();
//            var byteKey = Encoding.UTF8.GetBytes(key);
//            tripleDES.Key = byteKey;
//            tripleDES.Mode = CipherMode.ECB;
//            tripleDES.Padding = PaddingMode.PKCS7;
//            ICryptoTransform cTransform = tripleDES.CreateEncryptor();
//            byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
//            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
//        }
//        /// <summary>
//        /// DES 解密
//        /// </summary>
//        /// <param name="input"></param>
//        /// <param name="key"></param>
//        /// <returns></returns>
//        public static string DesDecrypt(string input, string key)
//        {
//            byte[] inputArray = Convert.FromBase64String(input);
//            var tripleDES = TripleDES.Create();
//            var byteKey = Encoding.UTF8.GetBytes(key);
//            tripleDES.Key = byteKey;
//            tripleDES.Mode = CipherMode.ECB;
//            tripleDES.Padding = PaddingMode.PKCS7;
//            ICryptoTransform cTransform = tripleDES.CreateDecryptor();
//            byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
//            return Encoding.UTF8.GetString(resultArray);
//        }


//        /// <summary>
//        /// AES 加密
//        /// </summary>
//        /// <param name="input"></param>
//        /// <param name="key"></param>
//        /// <returns></returns>
//        public static string AESEncrypt(string input, string key)
//        {
//            var encryptKey = Encoding.UTF8.GetBytes(key);

//            using (var aesAlg = Aes.Create())
//            {
//                using (var encryptor = aesAlg.CreateEncryptor(encryptKey, aesAlg.IV))
//                {
//                    using (var msEncrypt = new MemoryStream())
//                    {
//                        using (var csEncrypt = new CryptoStream(msEncrypt, encryptor,
//                            CryptoStreamMode.Write))

//                        using (var swEncrypt = new StreamWriter(csEncrypt))
//                        {
//                            swEncrypt.Write(input);
//                        }

//                        var iv = aesAlg.IV;

//                        var decryptedContent = msEncrypt.ToArray();

//                        var result = new byte[iv.Length + decryptedContent.Length];

//                        Buffer.BlockCopy(iv, 0, result, 0, iv.Length);
//                        Buffer.BlockCopy(decryptedContent, 0, result,
//                            iv.Length, decryptedContent.Length);

//                        return Convert.ToBase64String(result);
//                    }
//                }
//            }
//        }
//        /// <summary>
//        /// AES 解密
//        /// </summary>
//        /// <param name="input"></param>
//        /// <param name="key"></param>
//        /// <returns></returns>
//        public static string AESDecrypt(string input, string key)
//        {
//            var fullCipher = Convert.FromBase64String(input);

//            var iv = new byte[16];
//            var cipher = new byte[16];

//            Buffer.BlockCopy(fullCipher, 0, iv, 0, iv.Length);
//            Buffer.BlockCopy(fullCipher, iv.Length, cipher, 0, iv.Length);
//            var decryptKey = Encoding.UTF8.GetBytes(key);

//            using (var aesAlg = Aes.Create())
//            {
//                using (var decryptor = aesAlg.CreateDecryptor(decryptKey, iv))
//                {
//                    string result;
//                    using (var msDecrypt = new MemoryStream(cipher))
//                    {
//                        using (var csDecrypt = new CryptoStream(msDecrypt,
//                            decryptor, CryptoStreamMode.Read))
//                        {
//                            using (var srDecrypt = new StreamReader(csDecrypt))
//                            {
//                                result = srDecrypt.ReadToEnd();
//                            }
//                        }
//                    }

//                    return result;
//                }
//            }
//        }


//        /// <summary>
//        /// 使用MD5加密算法加密字符串
//        /// </summary>
//        /// <param name="quondamText">明文</param>
//        /// <returns>密文</returns>
//        public static string MD5(string quondamText = "")
//        {
//            if (string.IsNullOrEmpty(quondamText))
//            {
//                quondamText = "";
//            }
//            HashAlgorithm hashAlgorithm = System.Security.Cryptography.MD5.Create("md5");
//            byte[] data = hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes(quondamText));
//            return BytesToString(data);
//        }

//        /// <summary>
//        /// 验证MD5加密算法加密的字符串是否为指定明文的加密结果
//        /// </summary>
//        /// <param name="quondamText">明文</param>
//        /// <param name="cryptographText">密文</param>
//        /// <returns></returns>
//        public static bool ValidateByMD5(string quondamText, string cryptographText)
//        {
//            string cipherText = MD5(quondamText);
//            return (cipherText == cryptographText);
//        }




//        //判断是否Base64 数据
//        public static bool IsBase64(object val)
//        {
//            try
//            {
//                Convert.FromBase64String(val.ToString());
//                return true;
//            }
//            catch
//            {
//                return false;
//            }
//        }




//        #region ========加密========

//        /// <summary>
//        /// 加密
//        /// </summary>
//        /// <param name="Text"></param>
//        /// <returns></returns>
//        public static string EncryptData(string Text)
//        {
//            return EncryptData(Text, sKey);
//        }
//        /// <summary> 
//        /// 加密数据 
//        /// </summary> 
//        /// <param name="Text"></param> 
//        /// <param name="sKey"></param> 
//        /// <returns></returns> 
//        public static string EncryptData(string Text, string sKey = "huifudai")
//        {
//            try
//            {
//                DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//                byte[] inputByteArray;
//                inputByteArray = Encoding.Default.GetBytes(Text);
//                des.Key = ASCIIEncoding.ASCII.GetBytes(MD5(sKey).Substring(0, 8));
//                des.IV = ASCIIEncoding.ASCII.GetBytes(MD5(sKey).Substring(0, 8));
//                System.IO.MemoryStream ms = new System.IO.MemoryStream();
//                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
//                cs.Write(inputByteArray, 0, inputByteArray.Length);
//                cs.FlushFinalBlock();
//                StringBuilder ret = new StringBuilder();
//                foreach (byte b in ms.ToArray())
//                {
//                    ret.AppendFormat("{0:X2}", b);
//                }
//                return ret.ToString();
//            }
//            catch { return string.Empty; }
//        }


//        #endregion

//        #region ========解密========


//        /// <summary>
//        /// 解密
//        /// </summary>
//        /// <param name="Text"></param>
//        /// <returns></returns>
//        public static string DecryptData(string Text)
//        {
//            return DecryptData(Text, sKey);
//        }
//        /// <summary> 
//        /// 解密数据 
//        /// </summary> 
//        /// <param name="Text"></param> 
//        /// <param name="sKey"></param> 
//        /// <returns></returns> 
//        public static string DecryptData(string Text, string sKey = "00000000")
//        {
//            try
//            {
//                DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//                int len;
//                len = Text.Length / 2;
//                byte[] inputByteArray = new byte[len];
//                int x, i;
//                for (x = 0; x < len; x++)
//                {
//                    i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
//                    inputByteArray[x] = (byte)i;
//                }
//                des.Key = ASCIIEncoding.ASCII.GetBytes(MD5(sKey).Substring(0, 8));
//                des.IV = ASCIIEncoding.ASCII.GetBytes(MD5(sKey).Substring(0, 8));
//                System.IO.MemoryStream ms = new System.IO.MemoryStream();
//                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
//                cs.Write(inputByteArray, 0, inputByteArray.Length);
//                cs.FlushFinalBlock();
//                return Encoding.Default.GetString(ms.ToArray());
//            }
//            catch { return string.Empty; }
//        }

//        #endregion



//        /// <summary>
//        /// AES加密
//        /// </summary>
//        /// <param name="Data">被加密的明文</param>
//        /// <param name="Key">密钥</param>
//        /// <param name="Vector">向量</param>
//        /// <returns>密文</returns>
//        public static Byte[] AESEncrypt(Byte[] Data, String Key, String Vector)
//        {
//            Byte[] bKey = new Byte[32];
//            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
//            Byte[] bVector = new Byte[16];
//            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

//            Byte[] Cryptograph = null; // 加密后的密文

//            Rijndael Aes = Rijndael.Create();
//            try
//            {
//                // 开辟一块内存流
//                using (MemoryStream Memory = new MemoryStream())
//                {
//                    // 把内存流对象包装成加密流对象
//                    using (CryptoStream Encryptor = new CryptoStream(Memory,
//                    Aes.CreateEncryptor(bKey, bVector),
//                    CryptoStreamMode.Write))
//                    {
//                        // 明文数据写入加密流
//                        Encryptor.Write(Data, 0, Data.Length);
//                        Encryptor.FlushFinalBlock();

//                        Cryptograph = Memory.ToArray();
//                    }
//                }
//            }
//            catch
//            {
//                Cryptograph = null;
//            }

//            return Cryptograph;
//        }

//        /// <summary>
//        /// AES解密
//        /// </summary>
//        /// <param name="Data">被解密的密文</param>
//        /// <param name="Key">密钥</param>
//        /// <param name="Vector">向量</param>
//        /// <returns>明文</returns>
//        public static Byte[] AESDecrypt(Byte[] Data, String Key, String Vector)
//        {
//            Byte[] bKey = new Byte[32];
//            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
//            Byte[] bVector = new Byte[16];
//            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

//            Byte[] original = null; // 解密后的明文

//            Rijndael Aes = Rijndael.Create();
//            try
//            {
//                // 开辟一块内存流，存储密文
//                using (MemoryStream Memory = new MemoryStream(Data))
//                {
//                    // 把内存流对象包装成加密流对象
//                    using (CryptoStream Decryptor = new CryptoStream(Memory,
//                    Aes.CreateDecryptor(bKey, bVector),
//                    CryptoStreamMode.Read))
//                    {
//                        // 明文存储区
//                        using (MemoryStream originalMemory = new MemoryStream())
//                        {
//                            Byte[] Buffer = new Byte[1024];
//                            Int32 readBytes = 0;
//                            while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
//                            {
//                                originalMemory.Write(Buffer, 0, readBytes);
//                            }

//                            original = originalMemory.ToArray();
//                        }
//                    }
//                }
//            }
//            catch
//            {
//                original = null;
//            }

//            return original;
//        }



//        /// <summary>
//        /// 字节转换为字符串
//        /// </summary>
//        /// <param name="bytes">字符</param>
//        /// <returns>字符串</returns>
//        public static string BytesToString(byte[] bytes)
//        {
//            StringBuilder sBuilder = new StringBuilder();
//            foreach (byte bit in bytes)
//            {
//                sBuilder.Append(bit.ToString("X2"));
//            }
//            return sBuilder.ToString();
//        }


//        /// <summary>
//        /// 字符串转换为字符
//        /// </summary>
//        /// <param name="str">字符串</param>
//        /// <returns>字符</returns>
//        public static byte[] StringToBytes(string str)
//        {
//            ArrayList lst = new ArrayList();
//            for (int i = 0; i < str.Length; i += 2)
//            {
//                string byteStr = str.Substring(i, 2);
//                lst.Add(byteStr);
//            }
//            byte[] bytes = new byte[lst.Count];
//            for (int i = 0; i < lst.Count; i++)
//            {
//                bytes[i] = Convert.ToByte(lst[i].ToString(), 16);
//            }
//            return bytes;
//        }






//        /// <summary>
//        /// 判断指定字符串是否包含相应的字符
//        /// </summary>
//        /// <param name="strSub"></param>
//        /// <param name="strMain"></param>
//        /// <returns></returns>
//        public static bool IsSubString(char strSub, string strMain)
//        {
//            foreach (char c in strMain.ToCharArray())
//            {
//                if (strSub == c)
//                {
//                    return true;
//                }
//            }
//            return false;
//        }




//        /// <summary>
//        /// Base64加密
//        /// </summary>
//        /// <param name="Message"></param>
//        /// <returns></returns>
//        public static string Base64Code(string Message)
//        {
//            char[] Base64Code = new char[]{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
//         'U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n',
//         'o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7',
//         '8','9','+','/','='};
//            byte empty = (byte)0;
//            System.Collections.ArrayList byteMessage = new System.Collections.ArrayList(System.Text.Encoding.Default.GetBytes(Message));
//            System.Text.StringBuilder outmessage;
//            int messageLen = byteMessage.Count;
//            int page = messageLen / 3;
//            int use = 0;
//            if ((use = messageLen % 3) > 0)
//            {
//                for (int i = 0; i < 3 - use; i++)
//                    byteMessage.Add(empty);
//                page++;
//            }
//            outmessage = new System.Text.StringBuilder(page * 4);
//            for (int i = 0; i < page; i++)
//            {
//                byte[] instr = new byte[3];
//                instr[0] = (byte)byteMessage[i * 3];
//                instr[1] = (byte)byteMessage[i * 3 + 1];
//                instr[2] = (byte)byteMessage[i * 3 + 2];
//                int[] outstr = new int[4];
//                outstr[0] = instr[0] >> 2;
//                outstr[1] = ((instr[0] & 0x03) << 4) ^ (instr[1] >> 4);
//                if (!instr[1].Equals(empty))
//                    outstr[2] = ((instr[1] & 0x0f) << 2) ^ (instr[2] >> 6);
//                else
//                    outstr[2] = 64;
//                if (!instr[2].Equals(empty))
//                    outstr[3] = (instr[2] & 0x3f);
//                else
//                    outstr[3] = 64;
//                outmessage.Append(Base64Code[outstr[0]]);
//                outmessage.Append(Base64Code[outstr[1]]);
//                outmessage.Append(Base64Code[outstr[2]]);
//                outmessage.Append(Base64Code[outstr[3]]);
//            }
//            return outmessage.ToString();
//        }

//        /// <summary>
//        /// Base64解密
//        /// </summary>
//        /// <param name="Message"></param>
//        /// <returns></returns>
//        public static string Base64Decode(string Message)
//        {
//            if ((Message.Length % 4) != 0)
//            {
//                throw new ArgumentException("不是正确的BASE64编码，请检查。", "Message");
//            }
//            if (!System.Text.RegularExpressions.Regex.IsMatch(Message, "^[A-Z0-9/+=]*{{1}}quot;", System.Text.RegularExpressions.RegexOptions.IgnoreCase))
//            {
//                throw new ArgumentException("包含不正确的BASE64编码，请检查。", "Message");
//            }
//            string Base64Code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
//            int page = Message.Length / 4;
//            System.Collections.ArrayList outMessage = new System.Collections.ArrayList(page * 3);
//            char[] message = Message.ToCharArray();
//            for (int i = 0; i < page; i++)
//            {
//                byte[] instr = new byte[4];
//                instr[0] = (byte)Base64Code.IndexOf(message[i * 4]);
//                instr[1] = (byte)Base64Code.IndexOf(message[i * 4 + 1]);
//                instr[2] = (byte)Base64Code.IndexOf(message[i * 4 + 2]);
//                instr[3] = (byte)Base64Code.IndexOf(message[i * 4 + 3]);
//                byte[] outstr = new byte[3];
//                outstr[0] = (byte)((instr[0] << 2) ^ ((instr[1] & 0x30) >> 4));
//                if (instr[2] != 64)
//                {
//                    outstr[1] = (byte)((instr[1] << 4) ^ ((instr[2] & 0x3c) >> 2));
//                }
//                else
//                {
//                    outstr[2] = 0;
//                }
//                if (instr[3] != 64)
//                {
//                    outstr[2] = (byte)((instr[2] << 6) ^ instr[3]);
//                }
//                else
//                {
//                    outstr[2] = 0;
//                }
//                outMessage.Add(outstr[0]);
//                if (outstr[1] != 0)
//                    outMessage.Add(outstr[1]);
//                if (outstr[2] != 0)
//                    outMessage.Add(outstr[2]);
//            }
//            byte[] outbyte = (byte[])outMessage.ToArray(Type.GetType("System.Byte"));
//            return System.Text.Encoding.Default.GetString(outbyte);
//        }


//    }
//}
